The maximum number of columns Oracle can store in a row piece is 255. So your 270 columns will be split over two row pieces.

http://docs.oracle.com/database/121/CNCPT/logical.htm#CNCPT1055

These may be in different blocks or they may be in the same block. It depends on the values you're inserting and how much space there is left in the block at the time!

So if you select the whole row or columns at the "end" of the table, there will be extra work compared to a table with 255 columns or less.

You can see this in the example below. I create a 300 column table, insert one row and add an index.

Selecting just the first columns in the table gives two gets (one for the index, one for the row).

But selecting the whole row or just the columns at the end gives three gets (one for the index, two for the two row pieces).

declare
  tab_sql varchar2(4000);
  ins_sql varchar2(4000);
begin
with rws as (
  select 'create table t ( ' 
  || listagg('col'||rownum || ' int', ',') within group (order by rownum) 
  || ')' tab,
  'insert into t values ( ' 
  || listagg('1', ',') within group (order by rownum) 
  || ')' ins
  from dual connect by level <= 300
)
  select *
  into   tab_sql, ins_sql
  from rws;
  
  execute immediate tab_sql;
  execute immediate ins_sql;
end;
/
create index i on t(col1);

SQL> set autotrace trace stat
SQL> select /*+ index(t(col1))*/col1, col2, col3
  2  from t
  3  where  col1 = 1;


Statistics
----------------------------------------------------------
          0  recursive calls
          0  db block gets
          2  consistent gets
          0  physical reads
          0  redo size
        486  bytes sent via SQL*Net to client
        500  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          1  rows processed

SQL>
SQL> select /*+ index(t(col1))*/* from t
  2  where  col1 = 1;


Statistics
----------------------------------------------------------
          0  recursive calls
          0  db block gets
          3  consistent gets
          0  physical reads
          0  redo size
      17929  bytes sent via SQL*Net to client
        500  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          1  rows processed

SQL>
SQL> select /*+ index(t(col1))*/col300
  2  from t
  3  where  col1 = 1;


Statistics
----------------------------------------------------------
          1  recursive calls
          0  db block gets
          3  consistent gets
          0  physical reads
          0  redo size
        374  bytes sent via SQL*Net to client
        500  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          1  rows processed

So there will be a small amount of extra work for some queries.

You can't really avoid this. Say you instead of altering your existing table you create a new one instead. Now you can have less than 255 rows in each.

But!

If you need to access all the columns you now need to join the two tables. So you've still got two gets to access the blocks from both tables. And you've probably got an extra index lookup for the new table too. So you've saved yourself one issue and created another!

As always test in your environment. Add the columns, see what impact it has. Consider alternatives if you need to based on the outcome of these tests.